<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  
  
  <title>Hexo</title>
  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
  <meta name="description" content="第十一章函数式接口01_函数式接口 函数式接口概念：有且仅有一个抽象方法的接口。 Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口。 只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。 如何检测一个接口是不是函数式接口：  @FunctionalInterface 放在接口定义的上方：如果接口是函数式接口，编译通过；">
<meta property="og:type" content="article">
<meta property="og:title" content="Hexo">
<meta property="og:url" content="https://goofyer.gitee.io/notes-on-computer-expertise/2021/12/20/Java/%E7%AC%AC%E5%8D%81%E4%B8%80%E7%AB%A0%E5%87%BD%E6%95%B0%E5%BC%8F%E6%8E%A5%E5%8F%A3/index.html">
<meta property="og:site_name" content="Hexo">
<meta property="og:description" content="第十一章函数式接口01_函数式接口 函数式接口概念：有且仅有一个抽象方法的接口。 Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口。 只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。 如何检测一个接口是不是函数式接口：  @FunctionalInterface 放在接口定义的上方：如果接口是函数式接口，编译通过；">
<meta property="og:locale" content="en_US">
<meta property="article:published_time" content="2021-12-19T17:33:08.446Z">
<meta property="article:modified_time" content="2021-12-19T17:33:09.565Z">
<meta property="article:author" content="John Doe">
<meta name="twitter:card" content="summary">
  
    <link rel="alternate" href="/notes-on-computer-expertise/atom.xml" title="Hexo" type="application/atom+xml">
  
  
    <link rel="shortcut icon" href="/notes-on-computer-expertise/favicon.png">
  
  
    
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/typeface-source-code-pro@0.0.71/index.min.css">

  
  
<link rel="stylesheet" href="/notes-on-computer-expertise/css/style.css">

  
    
<link rel="stylesheet" href="/notes-on-computer-expertise/fancybox/jquery.fancybox.min.css">

  
<meta name="generator" content="Hexo 5.4.0"></head>

<body>
  <div id="container">
    <div id="wrap">
      <header id="header">
  <div id="banner"></div>
  <div id="header-outer" class="outer">
    <div id="header-title" class="inner">
      <h1 id="logo-wrap">
        <a href="/notes-on-computer-expertise/" id="logo">Hexo</a>
      </h1>
      
    </div>
    <div id="header-inner" class="inner">
      <nav id="main-nav">
        <a id="main-nav-toggle" class="nav-icon"></a>
        
          <a class="main-nav-link" href="/notes-on-computer-expertise/">Home</a>
        
          <a class="main-nav-link" href="/notes-on-computer-expertise/archives">Archives</a>
        
      </nav>
      <nav id="sub-nav">
        
          <a id="nav-rss-link" class="nav-icon" href="/notes-on-computer-expertise/atom.xml" title="RSS Feed"></a>
        
        <a id="nav-search-btn" class="nav-icon" title="Search"></a>
      </nav>
      <div id="search-form-wrap">
        <form action="//google.com/search" method="get" accept-charset="UTF-8" class="search-form"><input type="search" name="q" class="search-form-input" placeholder="Search"><button type="submit" class="search-form-submit">&#xF002;</button><input type="hidden" name="sitesearch" value="https://goofyer.gitee.io/notes-on-computer-expertise"></form>
      </div>
    </div>
  </div>
</header>

      <div class="outer">
        <section id="main"><article id="post-Java/第十一章函数式接口" class="h-entry article article-type-post" itemprop="blogPost" itemscope itemtype="https://schema.org/BlogPosting">
  <div class="article-meta">
    <a href="/notes-on-computer-expertise/2021/12/20/Java/%E7%AC%AC%E5%8D%81%E4%B8%80%E7%AB%A0%E5%87%BD%E6%95%B0%E5%BC%8F%E6%8E%A5%E5%8F%A3/" class="article-date">
  <time class="dt-published" datetime="2021-12-19T17:33:08.446Z" itemprop="datePublished">2021-12-20</time>
</a>
    
  </div>
  <div class="article-inner">
    
    
    <div class="e-content article-entry" itemprop="articleBody">
      
        <h2 id="第十一章函数式接口"><a href="#第十一章函数式接口" class="headerlink" title="第十一章函数式接口"></a>第十一章函数式接口</h2><h3 id="01-函数式接口"><a href="#01-函数式接口" class="headerlink" title="01_函数式接口"></a>01_函数式接口</h3><ul>
<li>函数式接口概念：有且仅有一个抽象方法的接口。</li>
<li>Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口。</li>
<li>只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。</li>
<li><p>如何检测一个接口是不是函数式接口：</p>
<ul>
<li>@FunctionalInterface</li>
<li>放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败。</li>
</ul>
</li>
<li><p>注意事项：</p>
<ul>
<li>我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解。</li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>@FunctionalInterfacepublic interface MyInterface {<br>void show();<br>}</li>
</ul>
</li>
</ul>
<p>public class MyInterfaceDemo {<br>    public static void main(String[] args) {<br>        MyInterface my = () -&gt; System.out.println(“函数式接口”);<br>My.show();<br>    }<br>}</p>
<h3 id="02-函数式接口作为方法的参数"><a href="#02-函数式接口作为方法的参数" class="headerlink" title="02_函数式接口作为方法的参数"></a>02_函数式接口作为方法的参数</h3><ul>
<li><p>需求</p>
<ul>
<li>定义一个类(RunnableDemo)，在类中提供两个方法：</li>
<li>一个方法是：startThread(Runnable r)   方法参数Runnable是一个函数式接口。</li>
<li>一个方法是主方法，在主方法中调用startThread方法。</li>
<li>如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递。</li>
<li>startThread(() -&gt; System.out.printIn(Thread.currentThread().getName() + “线程启动了”));</li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>@FunctionalInterface<br>public interface Runnable {<br>public abstract void run();<br>}</li>
</ul>
</li>
</ul>
<p>public class RunnableDemo {<br> public static void main(String[] args) {<br>     startThread(new Runnable()){<br>         @Override<br>                 public void run(){<br>             System.out.println(“线程启动了”);<br>         }<br>     }<br>        MyInterface my = () -&gt;<br>    }<br>    private static void startThread(Runnable r)<br>    {<br>        new Thread(r).start();<br>    }<br>}</p>
<h3 id="03-函数式接口作为方法的返回值"><a href="#03-函数式接口作为方法的返回值" class="headerlink" title="03_函数式接口作为方法的返回值"></a>03_函数式接口作为方法的返回值</h3><ul>
<li><p>需求描述</p>
<ul>
<li>定义一个类(ComparatorDemo)，在类中提供两个方法：</li>
<li>一个方法是：Comparator<String> getComparator()   方法返回值Comparator是一个函数式接口。</li>
<li>一个方法是主方法，在主方法中调用getComparator方法。</li>
<li>如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回。</li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>private static Comparator<String> getComparator() {<br>  return (s1, s2) -&gt; s1.length() - s2.length();</li>
</ul>
</li>
</ul>
<p>}</p>
<pre><code>- 子主题 2
- 子主题 3
</code></pre><h3 id="04-常用函数式接口之Supplier"><a href="#04-常用函数式接口之Supplier" class="headerlink" title="04_常用函数式接口之Supplier"></a>04_常用函数式接口之Supplier</h3><ul>
<li>Java8在java.util.function包下预定义了大量的函数式接口供我们使用。</li>
<li><p>我们重点来学习下面的4个接口：</p>
<ul>
<li><p>Supplier接口</p>
<ul>
<li>Supplier<T>：包含一个无参的方法。</li>
<li>T get()：获得结果。</li>
<li>该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据。</li>
<li>Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。</li>
<li>常用方法：只有一个无参的方法。</li>
</ul>
</li>
<li><p>Consumer接口</p>
</li>
<li>Predicate接口</li>
<li>Function接口</li>
</ul>
</li>
<li><p>子主题 3</p>
</li>
<li>子主题 4</li>
<li>子主题 5</li>
<li>子主题 6</li>
<li>子主题 7</li>
</ul>
<h3 id="子主题-116"><a href="#子主题-116" class="headerlink" title="子主题 116"></a>子主题 116</h3><h3 id="05-Supplier接口练习之获取最大值"><a href="#05-Supplier接口练习之获取最大值" class="headerlink" title="05_Supplier接口练习之获取最大值"></a>05_Supplier接口练习之获取最大值</h3><ul>
<li><p>1.5、Supplier接口</p>
<ul>
<li>Supplier<T>：包含一个无参的方法。</li>
<li><p>T get()：获得结果。</p>
<ul>
<li>该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据。</li>
</ul>
</li>
<li><p>Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。</p>
</li>
</ul>
</li>
<li><p>练习（案例需求）</p>
<ul>
<li><p>定义一个类(SupplierTest)，在类中提供两个方法：</p>
<ul>
<li>一个方法是：int getMax(Supplier<Integer> sup) 用于返回一个int数组中的最大值</li>
<li>一个方法是主方法，在主方法中调用getMax方法</li>
<li>public class SupplierTest {<br>//返回一个int数组的最大值<br>private static int getMax(Supplier<int> sup) {<br>return sup.get();<br>}</li>
</ul>
<p>public static void main(String[] args) {<br>  int[] arr = {19, 50, 658, 54, 5};<br>  int maxValue = getMax(() -&gt; {</p>
<pre><code>  int max = arr[0];
  for (int i = 1; i &lt; arr.length; i++) &#123;
      if (arr[i] &gt; max)
          max = arr[i];
  &#125;
  return max;
</code></pre><p>  });<br>}<br>}</p>
</li>
</ul>
</li>
</ul>
<h3 id="06-常用函数式接口之Consumer"><a href="#06-常用函数式接口之Consumer" class="headerlink" title="06_常用函数式接口之Consumer"></a>06_常用函数式接口之Consumer</h3><ul>
<li>Consumer<T>：包含两个方法。</li>
<li>void accept(T t)：对给定的参数执行此操作。</li>
<li>default Consumer<T> andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行 after操作。</li>
<li>Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定。</li>
<li>public interface Cinsumer<T>{<br>  void accept(T t);<br>  default Consumer<T> andThen(Consumer&lt;? super T&gt;after){<pre><code>  Objects.requireNonNull(after);
  return (T t)-&gt;&#123;accept(t);after.accept(t);&#125;;
</code></pre>  }<br>}</li>
</ul>
<h3 id="07-Consumer接口练习之按要求打印信息"><a href="#07-Consumer接口练习之按要求打印信息" class="headerlink" title="07_Consumer接口练习之按要求打印信息"></a>07_Consumer接口练习之按要求打印信息</h3><ul>
<li>Consumer<T>：包含两个方法。</li>
<li>void accept(T t)：对给定的参数执行此操作。</li>
<li>default Consumer<T> andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行 after操作。</li>
<li>Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定。</li>
<li><p>练习（案例需求）</p>
<ul>
<li>String[] strArray = {“林青霞,30”, “张曼玉,35”, “王祖贤,33”};</li>
<li>字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX”的格式将信息打印出来。</li>
<li><p>要求：</p>
<ul>
<li>把打印姓名的动作作为第一个Consumer接口的Lambda实例。</li>
<li>把打印年龄的动作作为第二个Consumer接口的Lambda实例。</li>
<li>将两个Consumer接口按照顺序组合到一起使用。</li>
</ul>
</li>
</ul>
</li>
</ul>
<h3 id="08-常用函数式接口之Predicate-1"><a href="#08-常用函数式接口之Predicate-1" class="headerlink" title="08_常用函数式接口之Predicate(1)"></a>08_常用函数式接口之Predicate(1)</h3><ul>
<li><p>Predicate<T>：常用的四个方法：</p>
<ul>
<li>boolean test(T t)：对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值。</li>
<li>default Predicate<T> negate()：返回一个逻辑的否定，对应逻辑非。</li>
<li>default Predicate<T> and(Predicate other)：返回一个组合判断，对应短路与。</li>
<li>default Predicate<T> or(Predicate other)：返回一个组合判断，对应短路或。</li>
<li>Predicate<T>接口通常用于判断参数是否满足指定的条件。</li>
</ul>
</li>
</ul>
<h3 id="09-常用函数式接口之Predicate-2"><a href="#09-常用函数式接口之Predicate-2" class="headerlink" title="09_常用函数式接口之Predicate(2)"></a>09_常用函数式接口之Predicate(2)</h3><ul>
<li><p>Predicate<T>：常用的四个方法：</p>
<ul>
<li>boolean test(T t)：对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值。</li>
<li>default Predicate<T> negate()：返回一个逻辑的否定，对应逻辑非。</li>
<li>default Predicate<T> and(Predicate other)：返回一个组合判断，对应短路与。</li>
<li>default Predicate<T> or(Predicate other)：返回一个组合判断，对应短路或。</li>
<li>Predicate<T>接口通常用于判断参数是否满足指定的条件。</li>
</ul>
</li>
</ul>
<h3 id="代码"><a href="#代码" class="headerlink" title="代码"></a>代码</h3><ul>
<li>10_Predicate接口练习之筛选满足条件数据</li>
<li><p>Predicate<T>：常用的四个方法：</p>
<ul>
<li>boolean test(T t)：对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值。</li>
<li>default Predicate<T> negate()：返回一个逻辑的否定，对应逻辑非。</li>
<li>default Predicate<T> and(Predicate other)：返回一个组合判断，对应短路与。</li>
<li>default Predicate<T> or(Predicate other)：返回一个组合判断，对应短路或。</li>
</ul>
</li>
<li><p>Predicate<T>接口通常用于判断参数是否满足指定的条件。</p>
</li>
<li><p>练习描述</p>
<ul>
<li>String[] strArray = {“林青霞,30”, “柳岩,34”, “张曼玉,35”, “貂蝉,31”, “王祖贤,33”};</li>
<li>字符串数组中有多条信息，请通过Predicate接口的拼装 将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合。</li>
<li>同时满足如下要求：姓名长度大于2；年龄大于33。</li>
</ul>
</li>
<li><p>分析</p>
<ul>
<li>1.有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断。</li>
<li>2.必须同时满足两个条件,所以可以使用and方法连接两个判断条件。</li>
</ul>
</li>
<li><p>代码</p>
</li>
</ul>
<h3 id="11-常用函数式接口之Function"><a href="#11-常用函数式接口之Function" class="headerlink" title="11_常用函数式接口之Function"></a>11_常用函数式接口之Function</h3><ul>
<li>Function<T,R>：常用的两个方法：</li>
<li>R apply​(T t)：将此函数应用于给定的参数。</li>
<li>default <V> Function andThen​(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果。</li>
<li>Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值。</li>
<li><p>代码</p>
<ul>
<li>1.8、Function接口</li>
</ul>
</li>
<li><p>子主题 6</p>
</li>
</ul>
<h3 id="12-Function接口练习之按照指定要求操作数据"><a href="#12-Function接口练习之按照指定要求操作数据" class="headerlink" title="12_Function接口练习之按照指定要求操作数据"></a>12_Function接口练习之按照指定要求操作数据</h3><ul>
<li>Function<T,R>：常用的两个方法：</li>
<li>R apply​(T t)：将此函数应用于给定的参数。</li>
<li>default <V> Function andThen​(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果。</li>
<li>Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值。</li>
<li><p>练习描述</p>
<ul>
<li>String s = “林青霞,30”;</li>
<li>请按照指定的要求进行操作：</li>
<li>将字符串截取得到数字年龄部分</li>
<li>将上一步的年龄字符串转换成为int类型的数据</li>
<li>将上一步的int数据加70，得到一个int结果，在控制台输出</li>
<li>请通过Function接口来实现函数拼接</li>
</ul>
</li>
<li><p>代码</p>
</li>
</ul>
<h3 id="13-体验Stream流"><a href="#13-体验Stream流" class="headerlink" title="13_体验Stream流"></a>13_体验Stream流</h3><ul>
<li><p>案例需求：按照下面的要求完成集合的创建和遍历。</p>
<ul>
<li>创建一个集合，存储多个字符串元素；</li>
<li>把集合中所有以”张”开头的元素存储到一个新的集合；</li>
<li>把”张”开头的集合中的长度为3的元素存储到一个新的集合；</li>
<li>遍历上一步得到的集合。</li>
<li>使用Stream流的方式完成过滤操作（Stream流的好处）：</li>
<li>list.stream().filter(s -&gt; s.startsWith(“张”)).filter(s -&gt; s.length() == 3).forEach(System.out::println);</li>
<li>直接阅读代码的字面意思，即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。</li>
<li>Stream流把真正的函数式编程风格引入到Java中。</li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>package com.itheima_01;</li>
</ul>
</li>
</ul>
<p>import java.util.ArrayList;</p>
<p>public class StreamDemo {<br>    public static void main(String[] args) {<br>        //1.创建一个集合，存储多个字符串元素<br>        ArrayList<String> list = new ArrayList<String>();<br>        list.add(“林青霞”);<br>        list.add(“张曼玉”);<br>        list.add(“王祖贤”);<br>        list.add(“柳岩”);<br>        list.add(“张敏”);<br>        list.add(“张无忌”);<br>        //2.把集合中所有以”张”开头的元素存储到一个新的集合<br>        ArrayList<String> zhangList = new ArrayList<String>();<br>        for (String s : list) {<br>            if (s.startsWith(“张”)) {<br>                zhangList.add(s);<br>            }<br>        }<br>        System.out.println(zhangList);<br>        //3.把”张”开头的集合中的长度为3的元素存储到一个新的集合<br>        ArrayList<String> threeList = new ArrayList<String>();<br>        for (String s : zhangList) {<br>            if (s.length() == 3) {<br>                threeList.add(s);<br>            }<br>        }<br>        System.out.println(threeList);<br>        //4.遍历上一步得到的集合<br>        for (String s : threeList) {<br>            System.out.println(s);<br>        }<br>        System.out.println(“————“);<br>        //Stream流来改进<br>        list.stream().filter(s -&gt; s.startsWith(“张”)).filter(s -&gt; s.length() == 3).forEach(s -&gt; System.out.println(s));<br>        list.stream().filter(s -&gt; s.startsWith(“张”)).filter(s -&gt; s.length() == 3).forEach(System.out::println);<br>    }<br>}</p>
<h3 id="14-Stream流的常见生成方式"><a href="#14-Stream流的常见生成方式" class="headerlink" title="14_Stream流的常见生成方式"></a>14_Stream流的常见生成方式</h3><ul>
<li>Stream流的思想</li>
<li><p>Stream流的使用</p>
<ul>
<li><p>生成流</p>
<ul>
<li>通过数据源(集合、数组等)生成流</li>
<li>list.stream()</li>
</ul>
</li>
<li><p>中间操作</p>
<ul>
<li>一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用</li>
<li>filter()</li>
</ul>
</li>
<li><p>终结操作</p>
<ul>
<li>一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。</li>
<li>forEach()</li>
</ul>
</li>
</ul>
</li>
<li><p>Stream流的常见生成方式</p>
<ul>
<li>Collection体系的集合可以使用默认方法stream​()生成流</li>
<li>default Stream<E> stream​()</li>
<li>Map体系的集合间接的生成流</li>
<li>数组可以通过Stream接口的静态方法of​(T… values)生成流</li>
<li>package com.itheima_02;</li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>import java.util.*;<br>import java.util.stream.Stream;</li>
</ul>
</li>
</ul>
<p>public class StreamDemo {<br>    public static void main(String[] args) {<br>        //1.Collection体系的集合可以使用默认方法stream​()生成流<br>        List<String> list = new ArrayList<String>();<br>        Stream<String> listStream = list.stream();</p>
<pre><code>    Set&lt;String&gt; set = new HashSet&lt;String&gt;();
    Stream&lt;String&gt; setStream = set.stream();

    //2.Map体系的集合间接的生成流
    Map&lt;String, Integer&gt; map = new HashMap&lt;String, Integer&gt;();
    Stream&lt;String&gt; keyStream = map.keySet().stream();
    Stream&lt;Integer&gt; valueStream = map.values().stream();
    Stream&lt;Map.Entry&lt;String, Integer&gt;&gt; entryStream = map.entrySet().stream();

    //3.数组可以通过Stream接口的静态方法of​(T... values)生成流
    String[] strArray = &#123;&quot;hello&quot;, &quot;world&quot;, &quot;java&quot;&#125;;
    Stream&lt;String&gt; strArrayStream1 = Stream.of(strArray);
    Stream&lt;String&gt; strArrayStream2 = Stream.of(&quot;hello&quot;, &quot;world&quot;, &quot;java&quot;);
    Stream&lt;Integer&gt; intStream = Stream.of(10, 20, 30);
&#125;
</code></pre><p>}</p>
<h3 id="15-Stream流中间操作之filter"><a href="#15-Stream流中间操作之filter" class="headerlink" title="15_Stream流中间操作之filter"></a>15_Stream流中间操作之filter</h3><ul>
<li>概念：中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作。</li>
<li>Stream<T> filter​(Predicate predicate)：用于对流中的数据进行过滤。</li>
<li>Predicate接口中的方法    boolean test​(T t)：对给定的参数进行判断，返回一个布尔值。</li>
<li><p>代码</p>
<ul>
<li>子主题 1</li>
</ul>
</li>
</ul>
<h3 id="16-Stream流中间操作之limit-amp-skip"><a href="#16-Stream流中间操作之limit-amp-skip" class="headerlink" title="16_Stream流中间操作之limit&amp;skip"></a>16_Stream流中间操作之limit&amp;skip</h3><ul>
<li>Stream<T> filter​(Predicate predicate)：用于对流中的数据进行过滤。</li>
<li>Predicate接口中的方法    boolean test​(T t)：对给定的参数进行判断，返回一个布尔值。</li>
<li>Stream<T> limit​(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据。</li>
<li>Stream<T> skip​(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流。</li>
<li><p>代码</p>
<ul>
<li>子主题 1</li>
</ul>
</li>
</ul>
<h3 id="17-Stream流中间操作之concat-amp-distinct"><a href="#17-Stream流中间操作之concat-amp-distinct" class="headerlink" title="17_Stream流中间操作之concat&amp;distinct"></a>17_Stream流中间操作之concat&amp;distinct</h3><ul>
<li><p>1.3、Stream流的常见中间操作方法</p>
<ul>
<li>Stream<T> filter​(Predicate predicate)：用于对流中的数据进行过滤。</li>
<li>Predicate接口中的方法    boolean test​(T t)：对给定的参数进行判断，返回一个布尔值。</li>
<li>Stream<T> limit​(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据。</li>
<li>Stream<T> skip​(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流。</li>
<li>static <T> Stream<T> concat​(Stream a, Stream b)：合并a和b两个流为一个流。</li>
<li>Stream<T> distinct​()：返回由该流的不同元素（根据Object.equals(Object) ）组成的流。</li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>子主题 1</li>
</ul>
</li>
</ul>
<h3 id="18-Stream流中间操作之sorted"><a href="#18-Stream流中间操作之sorted" class="headerlink" title="18_Stream流中间操作之sorted"></a>18_Stream流中间操作之sorted</h3><ul>
<li><p>1.3、Stream流的常见中间操作方法</p>
<ul>
<li>Stream<T> filter​(Predicate predicate)：用于对流中的数据进行过滤。</li>
<li>Predicate接口中的方法    boolean test​(T t)：对给定的参数进行判断，返回一个布尔值。</li>
<li>Stream<T> limit​(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据。</li>
<li>Stream<T> skip​(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流。</li>
<li>static <T> Stream<T> concat​(Stream a, Stream b)：合并a和b两个流为一个流。</li>
<li>Stream<T> distinct​()：返回由该流的不同元素（根据Object.equals(Object) ）组成的流。</li>
<li>Stream<T> sorted​()：返回由此流的元素组成的流，根据自然顺序排序。</li>
<li>Stream<T> sorted​(Comparator comparator)：返回由该流的元素组成的流，根据提供的Comparator进行排序。</li>
<li>Comparator接口中的方法int compare​(T o1, T o2)</li>
</ul>
</li>
<li><p>代码</p>
</li>
</ul>
<h3 id="19-Stream流中间操作之map-amp-mapToInt"><a href="#19-Stream流中间操作之map-amp-mapToInt" class="headerlink" title="19_Stream流中间操作之map&amp;mapToInt"></a>19_Stream流中间操作之map&amp;mapToInt</h3><ul>
<li><p>1.3、Stream流的常见中间操作方法</p>
<ul>
<li>概念：中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作。</li>
<li>Stream<T> filter​(Predicate predicate)：用于对流中的数据进行过滤。</li>
<li>Predicate接口中的方法    boolean test​(T t)：对给定的参数进行判断，返回一个布尔值。</li>
<li>Stream<T> limit​(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据。</li>
<li>Stream<T> skip​(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流。</li>
<li>static <T> Stream<T> concat​(Stream a, Stream b)：合并a和b两个流为一个流。</li>
<li>Stream<T> distinct​()：返回由该流的不同元素（根据Object.equals(Object) ）组成的流。</li>
<li>Stream<T> sorted​()：返回由此流的元素组成的流，根据自然顺序排序。</li>
<li>Stream<T> sorted​(Comparator comparator)：返回由该流的元素组成的流，根据提供的Comparator进行排序。</li>
<li>Comparator接口中的方法    int compare​(T o1, T o2)</li>
<li><R> Stream<R> map​(Function mapper)：返回由给定函数应用于此流的元素的结果组成的流。</li>
</ul>
</li>
<li><p>代码</p>
</li>
<li><p>Function接口中的方法        R apply​(T t)</p>
<ul>
<li>IntStream mapToInt​(ToIntFunction mapper)：返回一个IntStream其中包含将给定函数应用于此流的元素的结果。</li>
<li>IntStream：表示原始 int 流</li>
<li>ToIntFunction接口中的方法     int applyAsInt​(T value)</li>
</ul>
</li>
</ul>
<h3 id="20-Stream流终结"><a href="#20-Stream流终结" class="headerlink" title="20_Stream流终结"></a>20_Stream流终结</h3><ul>
<li>概念：终结操作的意思是，执行完此方法之后，Stream流将不能再执行其他操作。</li>
<li><p>1.4、Stream流的常见终结操作方法</p>
<ul>
<li>void forEach(Consumer action)：对此流的每个元素执行操作。</li>
</ul>
</li>
<li><p>Consumer接口中的方法</p>
<ul>
<li>void accept​(T t)：对给定的参数执行此操作</li>
<li>long count()：返回此流中的元素数。</li>
</ul>
</li>
<li><p>代码</p>
</li>
</ul>
<h3 id="21-Stream流综合练习操作之forEach-amp-count"><a href="#21-Stream流综合练习操作之forEach-amp-count" class="headerlink" title="21_Stream流综合练习操作之forEach&amp;count"></a>21_Stream流综合练习操作之forEach&amp;count</h3><ul>
<li><p>案例需求：现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作：</p>
<ul>
<li>男演员只要名字为3个字的前三人；</li>
<li>女演员只要姓林的，并且不要第一个；</li>
<li>把过滤后的男演员姓名和女演员姓名合并到一起；</li>
<li>把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据。</li>
<li>演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法。</li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>子主题 2</li>
<li>子主题 3</li>
</ul>
</li>
</ul>
<h3 id="22-Stream流的收集操作"><a href="#22-Stream流的收集操作" class="headerlink" title="22_Stream流的收集操作"></a>22_Stream流的收集操作</h3><ul>
<li><p>概念：</p>
<ul>
<li>对数据使用Stream流的方式操作完毕后，可以把流中的数据收集到集合中。</li>
<li><p>Stream流的收集方法：</p>
<ul>
<li><p>R collect​(Collector collector)：把结果收集到集合中</p>
<ul>
<li><p>但是这个收集方法的参数是一个Collector接口。它是通过工具类Collectors提供了具体的收集方式：</p>
<ul>
<li>public static <T> Collector toList​()：把元素收集到List集合中</li>
<li>Public static <T> Collector toSet​()：把元素收集到Set集合中</li>
<li>Public static Collector toMap​(Function keyMapper,Function valueMapper)：把元素收集到Map集合中</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>package com.itheima_06;</li>
</ul>
</li>
</ul>
<p>import java.util.*;<br>import java.util.stream.Collectors;<br>import java.util.stream.Stream;</p>
<p>public class CollectDemo {<br>    public static void main(String[] args) {<br>        //创建List集合对象<br>        List<String> list = new ArrayList<String>();<br>        list.add(“林青霞”);<br>        list.add(“张曼玉”);<br>        list.add(“王祖贤”);<br>        list.add(“柳岩”);</p>
<pre><code>    //需求1：得到名字为3个字的流
    Stream&lt;String&gt; listStream = list.stream().filter(s -&gt; s.length() == 3);

    //需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
    List&lt;String&gt; names = listStream.collect(Collectors.toList());
    for (String name : names) &#123;
        System.out.println(name);
    &#125;

    //创建Set集合对象
    Set&lt;Integer&gt; set = new HashSet&lt;Integer&gt;();
    set.add(10);
    set.add(20);
    set.add(30);
    set.add(33);
    set.add(35);

    //需求3：得到年龄大于25的流
    Stream&lt;Integer&gt; setStream = set.stream().filter(age -&gt; age &gt; 25);

    //需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
    Set&lt;Integer&gt; ages = setStream.collect(Collectors.toSet());
    for (Integer age : ages) &#123;
        System.out.println(age);
    &#125;

    //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
    String[] strArray = &#123;&quot;林青霞,30&quot;, &quot;张曼玉,35&quot;, &quot;王祖贤,33&quot;, &quot;柳岩,25&quot;&#125;;

    //需求5：得到字符串中年龄数据大于28的流
    Stream&lt;String&gt; arrayStream = Stream.of(strArray).filter(s -&gt; Integer.parseInt(s.split(&quot;,&quot;)[1]) &gt; 28);

    //需求6：把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
    Map&lt;String, Integer&gt; map = arrayStream.collect(Collectors.toMap(s -&gt; s.split(&quot;,&quot;)[0], s -&gt; Integer.parseInt(s.split(&quot;,&quot;)[1])));

    Set&lt;String&gt; keySet = map.keySet();
    for (String key : keySet) &#123;
        Integer value = map.get(key);
        System.out.println(key + &quot;,&quot; + value);
    &#125;

&#125;
</code></pre><p>}</p>
<ul>
<li><p>01_类加载</p>
<ul>
<li><p>类加载的描述</p>
<ul>
<li>当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载、类的连接、类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化。</li>
</ul>
</li>
<li><p>类的加载</p>
<ul>
<li>就是指将class文件读入内存，并为之创建一个 java.lang.Class对象</li>
<li>任何类被使用时，系统都会为之建立一个 java.lang.Class 对象</li>
</ul>
</li>
<li><p>类的连接</p>
<ul>
<li>验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致</li>
<li>准备阶段：负责为类的类变量分配内存，并设置默认初始化值</li>
<li>解析阶段：将类的二进制数据中的符号引用替换为直接引用</li>
</ul>
</li>
<li><p>类的初始化</p>
<ul>
<li>在该阶段，主要就是对类变量进行初始化</li>
</ul>
</li>
<li><p>类的初始化步骤</p>
<ul>
<li>假如类还未被加载和连接，则程序先加载并连接该类</li>
<li>假如该类的直接父类还未被初始化，则先初始化其直接父类</li>
<li>假如类中有初始化语句，则系统依次执行这些初始化语句</li>
<li>注意：在执行第2个步骤的时候，系统对直接父类的初始化步骤也遵循初始化步骤1-3</li>
</ul>
</li>
<li><p>类的初始化时机：</p>
<ul>
<li>创建类的实例</li>
<li>调用类的类方法</li>
<li>访问类或者接口的类变量，或者为该类变量赋值</li>
<li>使用反射方式来强制创建某个类或接口对应的java.lang.Class对象</li>
<li>初始化某个类的子类</li>
<li>直接使用java.exe命令来运行某个主类</li>
</ul>
</li>
</ul>
</li>
<li><p>02_类加载器</p>
<ul>
<li><p>类加载器的作用：</p>
<ul>
<li>负责将.class文件加载到内存中，并为之生成对应的 java.lang.Class 对象。</li>
<li>虽然我们不用过分关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行！</li>
</ul>
</li>
<li><p>JVM的类加载机制：</p>
<ul>
<li>全盘负责：就是当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入。</li>
<li>父类委托：就是当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。</li>
<li>缓存机制：保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存储到缓存区。</li>
</ul>
</li>
<li><p>ClassLoader：是负责加载类的对象。</p>
</li>
<li><p>Java运行时，具有以下内置类加载器：</p>
<ul>
<li>Bootstrap class loader：它是虚拟机的内置类加载器，通常表示为null ，并且没有父null。</li>
<li>Platform class loader：平台类加载器可以看到所有平台类 ，平台类包括由平台类加载器或其祖先定义的Java SE平台API，其实现类和JDK特定的运行时类。</li>
<li>System class loader：它也被称为应用程序类加载器 ，与平台类加载器不同。系统类加载器通常用于定义应用程序类路径，模块路径和JDK特定工具上的类。</li>
<li>类加载器的继承关系：System的父加载器为Platform，而Platform的父加载器为Bootstrap。</li>
</ul>
</li>
<li><p>ClassLoader中的两个方法：</p>
<ul>
<li>static ClassLoader getSystemClassLoader()：返回用于委派的系统类加载器</li>
<li>ClassLoader getParent()：返回父类加载器进行委派</li>
</ul>
</li>
</ul>
</li>
<li><p>03_反射概述</p>
<ul>
<li>Java反射机制：是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展。</li>
</ul>
</li>
<li><p>04_获取Class类的对象</p>
<ul>
<li><p>我们要想通过反射去使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象。这里我们提供三种方式获取Class类型的对象：</p>
<ul>
<li>类名.class属性</li>
<li>对象名.getClass()方法</li>
<li>Class.forName(全类名)方法</li>
</ul>
</li>
<li><p>使用类的class属性来获取该类对应的Class对象。</p>
<ul>
<li>举例: Student.class将会返回Student类对应的Class对象。</li>
</ul>
</li>
<li><p>调用对象的getClass()方法，返回该对象所属类对应的Class对象</p>
</li>
<li>该方法是Object类中的方法，所有的Java对象都可以调用该方法</li>
<li>使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整包名的路径。</li>
</ul>
</li>
<li><p>05_反射获取构造方法并使用</p>
<ul>
<li><p>Class类中用于获取构造方法的方法</p>
<ul>
<li>Constructor&lt;?&gt;[] getConstructors()：返回所有公共构造方法对象的数组</li>
<li>Constructor&lt;?&gt;[] getDeclaredConstructors()：返回所有构造方法对象的数组</li>
<li>Constructor<T> getConstructor(Class&lt;?&gt;… parameterTypes)：返回单个公共构造方法对象</li>
<li>Constructor<T> getDeclaredConstructor(Class&lt;?&gt;… parameterTypes)：返回单个构造方法对象</li>
</ul>
</li>
<li><p>Constructor类中用于创建对象的方法</p>
<ul>
<li>T newInstance(Object…initargs)：根据指定的构造方法创建对象</li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>package com.itheima_03;</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>import com.itheima_02.Student;</p>
<p>import java.lang.reflect.Constructor;<br>import java.lang.reflect.InvocationTargetException;</p>
<p>/<em><br>    反射获取构造方法并使用
 </em>/<br>public class ReflectDemo01 {<br>    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {<br>        //获取Class对象<br>        Class&lt;?&gt; c = Class.forName(“com.itheima_02.Student”);</p>
<pre><code>    //Constructor&lt;?&gt;[] getConstructors​() 返回一个包含 Constructor对象的数组， Constructor对象反映了由该 Class对象表示的类的所有公共构造函数
    Constructor&lt;?&gt;[] cons = c.getConstructors();
    for (Constructor con : cons) &#123;
        System.out.println(con);
    &#125;
    System.out.println(&quot;--------&quot;);
    //Constructor&lt;?&gt;[] getDeclaredConstructors​() 返回反映由该 Class对象表示的类声明的所有构造函数的 Constructor对象的数组
    Constructor&lt;?&gt;[] cons2 = c.getDeclaredConstructors();
    for (Constructor con : cons2) &#123;
        System.out.println(con);
    &#125;
    System.out.println(&quot;--------&quot;);

    //Constructor&lt;T&gt; getConstructor​(Class&lt;?&gt;... parameterTypes) 返回一个 Constructor对象，该对象反映由该 Class对象表示的类的指定公共构造函数
    //Constructor&lt;T&gt; getDeclaredConstructor​(Class&lt;?&gt;... parameterTypes) 返回一个 Constructor对象，该对象反映由此 Class对象表示的类或接口的指定构造函数
    //参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象

    Constructor&lt;?&gt; con = c.getConstructor();

    //Constructor提供了一个类的单个构造函数的信息和访问权限
    //T newInstance​(Object... initargs) 使用由此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例
    Object obj = con.newInstance();
    System.out.println(obj);

    Student s = new Student();
    System.out.println(s);
&#125;
</code></pre><p>}</p>
<ul>
<li><p>06_反射获取构造方法并使用练习</p>
<ul>
<li><p>练习1：通过反射获取公共的构造方法并创建对象。</p>
<ul>
<li><p>public class ReflectDemo02 {<br>public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {<br>//获取Class对象<br>Class&lt;?&gt; c = Class.forName(“com.itheima_02.Student”);</p>
<p>//public Student(String name, int age, String address)<br>//Constructor<T> getConstructor​(Class&lt;?&gt;… parameterTypes)<br>Constructor&lt;?&gt; con = c.getConstructor(String.class, int.class, String.class);<br>//基本数据类型也可以通过.class得到对应的Class类型</p>
<p>//T newInstance​(Object… initargs)<br>Object obj = con.newInstance(“林青霞”, 30, “西安”);<br>System.out.println(obj);<br>}<br>}<br>基本数据类型也可以通过.class得到对应的Class类型。</p>
</li>
</ul>
</li>
<li><p>练习2：案例需求：通过反射获取私有构造方法并创建对象。</p>
<ul>
<li>Student s = new Student(“林青霞”);<br>System.out.println(s);<br>public void setAccessible​(boolean flag)：值为true，取消访问检查</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>package com.itheima_03;</p>
<p>import java.lang.reflect.Constructor;<br>import java.lang.reflect.InvocationTargetException;</p>
<p>public class ReflectDemo03 {<br>    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {<br>        //获取Class对象<br>        Class&lt;?&gt; c = Class.forName(“com.itheima_02.Student”);</p>
<pre><code>    //private Student(String name)
    //Constructor&lt;T&gt; getDeclaredConstructor​(Class&lt;?&gt;... parameterTypes)
    Constructor&lt;?&gt; con = c.getDeclaredConstructor(String.class);

    //暴力反射
    //public void setAccessible​(boolean flag):值为true，取消访问检查
    con.setAccessible(true);

    Object obj = con.newInstance(&quot;林青霞&quot;);
    System.out.println(obj);

&#125;
</code></pre><p>}</p>
<h3 id="代码-1"><a href="#代码-1" class="headerlink" title="代码"></a>代码</h3><ul>
<li><p>08_反射获取成员变量并使用</p>
<ul>
<li><p>Class类中用于获取成员变量的方法</p>
<ul>
<li>Field[] getFields()：返回所有公共成员变量对象的数组</li>
<li>Field[] getDeclaredFields()：返回所有成员变量对象的数组</li>
<li>Field getField(String name)：返回单个公共成员变量对象</li>
<li>Field getDeclaredField(String name)：返回单个成员变量对象</li>
</ul>
</li>
<li><p>Field类中用于给成员变量赋值的方法</p>
<ul>
<li>void set(Object obj, Object value)：给obj对象的成员变量赋值为value</li>
<li>Class Class<T></li>
</ul>
</li>
<li><p>代码</p>
<ul>
<li>package com.itheima_04;</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>import com.itheima_02.Student;</p>
<p>import java.lang.reflect.Constructor;<br>import java.lang.reflect.Field;<br>import java.lang.reflect.InvocationTargetException;</p>
<p>/<em><br>    反射获取成员变量并使用
 </em>/<br>public class ReflectDemo01 {<br>    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {<br>        //获取Class对象<br>        Class&lt;?&gt; c = Class.forName(“com.itheima_02.Student”);</p>
<pre><code>    //Field[] getFields​() 返回一个包含 Field对象的数组， Field对象反映由该 Class对象表示的类或接口的所有可访问的公共字段
    //Field[] getDeclaredFields​() 返回一个 Field对象的数组，反映了由该 Class对象表示的类或接口声明的所有字段
</code></pre><p>//        Field[] fields = c.getFields();<br>        Field[] fields = c.getDeclaredFields();<br>        for(Field field : fields) {<br>            System.out.println(field);<br>        }<br>        System.out.println(“————“);</p>
<pre><code>    //Field getField​(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定公共成员字段
    //Field getDeclaredField​(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定声明字段
    Field addressField = c.getField(&quot;address&quot;);

    //获取无参构造方法创建对象
    Constructor&lt;?&gt; con = c.getConstructor();
    Object obj = con.newInstance();
</code></pre><p>//        obj.addressField = “西安”;</p>
<pre><code>    //Field提供有关类或接口的单个字段的信息和动态访问
    //void set​(Object obj, Object value) 将指定的对象参数中由此 Field对象表示的字段设置为指定的新值
    addressField.set(obj,&quot;西安&quot;); //给obj的成员变量addressField赋值为西安

    System.out.println(obj);
</code></pre><p>//        Student s = new Student();<br>//        s.address = “西安”;<br>//        System.out.println(s);<br>    }<br>}</p>
<ul>
<li><p>09_反射获取成员变量并使用练习</p>
<ul>
<li><p>练习：voidset(Object obj,Object value)：给obj对象的成员变量赋值为value</p>
<ul>
<li>Student s = new Student();<br>s.name = “林青霞”;<br>s.age = 30;<br>s.address = “西安”;<br>System.out.println(s);</li>
<li>package com.itheima_04;</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>import java.lang.reflect.Constructor;<br>import java.lang.reflect.Field;<br>import java.lang.reflect.InvocationTargetException;</p>
<p>public class ReflectDemo02 {<br>    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {<br>        //获取Class对象<br>        Class&lt;?&gt; c = Class.forName(“com.itheima_02.Student”);</p>
<pre><code>    //Student s = new Student();
    Constructor&lt;?&gt; con = c.getConstructor();
    Object obj = con.newInstance();
    System.out.println(obj);

    //s.name = &quot;林青霞&quot;;
</code></pre><p>//        Field nameField = c.getField(“name”); //NoSuchFieldException: name<br>        Field nameField = c.getDeclaredField(“name”);<br>        nameField.setAccessible(true);<br>        nameField.set(obj, “林青霞”);<br>        System.out.println(obj);</p>
<pre><code>    //s.age = 30;
    Field ageField = c.getDeclaredField(&quot;age&quot;);
    ageField.setAccessible(true);
    ageField.set(obj, 30);
    System.out.println(obj);

    //s.address = &quot;西安&quot;;
    Field addressField = c.getDeclaredField(&quot;address&quot;);
    addressField.setAccessible(true);
    addressField.set(obj, &quot;西安&quot;);
    System.out.println(obj);
&#125;
</code></pre><p>}</p>
<h3 id="代码-2"><a href="#代码-2" class="headerlink" title="代码"></a>代码</h3><h3 id="代码-3"><a href="#代码-3" class="headerlink" title="代码"></a>代码</h3><h3 id="代码-4"><a href="#代码-4" class="headerlink" title="代码"></a>代码</h3><h3 id="代码-5"><a href="#代码-5" class="headerlink" title="代码"></a>代码</h3>
      
    </div>
    <footer class="article-footer">
      <a data-url="https://goofyer.gitee.io/notes-on-computer-expertise/2021/12/20/Java/%E7%AC%AC%E5%8D%81%E4%B8%80%E7%AB%A0%E5%87%BD%E6%95%B0%E5%BC%8F%E6%8E%A5%E5%8F%A3/" data-id="cl403sxrb001rf8vudwzq11vw" data-title="" class="article-share-link">Share</a>
      
      
      
    </footer>
  </div>
  
    
<nav id="article-nav">
  
    <a href="/notes-on-computer-expertise/2021/12/20/Java/%E7%AC%AC%E5%8D%81%E4%BA%8C%E7%AB%A0%20%E5%8F%8D%E5%B0%84/" id="article-nav-newer" class="article-nav-link-wrap">
      <strong class="article-nav-caption">Newer</strong>
      <div class="article-nav-title">
        
          (no title)
        
      </div>
    </a>
  
  
    <a href="/notes-on-computer-expertise/2021/12/20/Java/%E7%AC%AC%E5%8D%81%E7%AB%A0%20Lambda%E8%A1%A8%E8%BE%BE%E5%BC%8F/" id="article-nav-older" class="article-nav-link-wrap">
      <strong class="article-nav-caption">Older</strong>
      <div class="article-nav-title"></div>
    </a>
  
</nav>

  
</article>


</section>
        
          <aside id="sidebar">
  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Categories</h3>
    <div class="widget">
      <ul class="category-list"><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/C-%E5%B7%A5%E5%85%B7/">C#工具</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/C-%E5%B7%A5%E5%85%B7/">C++工具</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/Mysql/">Mysql</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/blender/">blender</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/linux/">linux</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/manim/">manim</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/spring/">spring</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/vba%E5%9F%BA%E7%A1%80%E6%93%8D%E4%BD%9C/">vba基础操作</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E5%88%9B%E9%80%A0%E6%A8%A1%E5%BC%8F/">创造模式</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/">操作系统</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86/">操作系统基础知识</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%BC%80%E5%8F%91/">操作系统开发</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E6%95%B0%E5%AD%A6/">数学</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/">数据结构</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86/">数据结构基础知识</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E6%A8%A1%E6%9D%BF/">模板</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/">深度学习</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E8%8B%B1%E8%AF%AD/">英语</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E8%99%9A%E5%B9%BB4/">虚幻4</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BB%84%E6%88%90%E5%8E%9F%E7%90%86/">计算机组成原理</a></li><li class="category-list-item"><a class="category-list-link" href="/notes-on-computer-expertise/categories/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/">计算机网络</a></li></ul>
    </div>
  </div>


  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Tags</h3>
    <div class="widget">
      <ul class="tag-list" itemprop="keywords"><li class="tag-list-item"><a class="tag-list-link" href="/notes-on-computer-expertise/tags/C/" rel="tag">C++</a></li></ul>
    </div>
  </div>


  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Tag Cloud</h3>
    <div class="widget tagcloud">
      <a href="/notes-on-computer-expertise/tags/C/" style="font-size: 10px;">C++</a>
    </div>
  </div>

  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Archives</h3>
    <div class="widget">
      <ul class="archive-list"><li class="archive-list-item"><a class="archive-list-link" href="/notes-on-computer-expertise/archives/2022/05/">May 2022</a></li><li class="archive-list-item"><a class="archive-list-link" href="/notes-on-computer-expertise/archives/2022/03/">March 2022</a></li><li class="archive-list-item"><a class="archive-list-link" href="/notes-on-computer-expertise/archives/2022/02/">February 2022</a></li><li class="archive-list-item"><a class="archive-list-link" href="/notes-on-computer-expertise/archives/2022/01/">January 2022</a></li><li class="archive-list-item"><a class="archive-list-link" href="/notes-on-computer-expertise/archives/2021/12/">December 2021</a></li></ul>
    </div>
  </div>


  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Recent Posts</h3>
    <div class="widget">
      <ul>
        
          <li>
            <a href="/notes-on-computer-expertise/2022/05/31/vue/%E5%89%8D%E7%AB%AF%E6%A1%86%E6%9E%B6%E9%AA%8C%E8%AF%81%E7%A0%81%E6%97%A0%E6%B3%95%E6%98%BE%E7%A4%BA/">(no title)</a>
          </li>
        
          <li>
            <a href="/notes-on-computer-expertise/2022/05/26/%E6%95%B0%E6%8D%AE%E5%BA%93/navicat%E5%AE%89%E8%A3%85/">(no title)</a>
          </li>
        
          <li>
            <a href="/notes-on-computer-expertise/2022/05/25/%E8%99%9A%E5%B9%BB4%E5%BC%95%E6%93%8E%E5%BC%80%E5%8F%91/%E8%99%9A%E5%B9%BB%E5%9B%9B%20mod%E5%88%B6%E4%BD%9C/">(no title)</a>
          </li>
        
          <li>
            <a href="/notes-on-computer-expertise/2022/05/23/python/python%E6%89%B9%E9%87%8F%E7%94%9F%E6%88%90%E6%95%B0%E6%8D%AE/">(no title)</a>
          </li>
        
          <li>
            <a href="/notes-on-computer-expertise/2022/05/23/vba%E5%9F%BA%E7%A1%80%E6%93%8D%E4%BD%9C%E7%AC%94%E8%AE%B0/EXCEL%E5%9F%BA%E7%A1%80%E6%95%99%E7%A8%8B/">(no title)</a>
          </li>
        
      </ul>
    </div>
  </div>

  
</aside>
        
      </div>
      <footer id="footer">
  
  <div class="outer">
    <div id="footer-info" class="inner">
      
      &copy; 2022 John Doe<br>
      Powered by <a href="https://hexo.io/" target="_blank">Hexo</a>
    </div>
  </div>
</footer>

    </div>
    <nav id="mobile-nav">
  
    <a href="/notes-on-computer-expertise/" class="mobile-nav-link">Home</a>
  
    <a href="/notes-on-computer-expertise/archives" class="mobile-nav-link">Archives</a>
  
</nav>
    


<script src="/notes-on-computer-expertise/js/jquery-3.4.1.min.js"></script>



  
<script src="/notes-on-computer-expertise/fancybox/jquery.fancybox.min.js"></script>




<script src="/notes-on-computer-expertise/js/script.js"></script>





  </div>
<script type="text/x-mathjax-config">
    MathJax.Hub.Config({
        tex2jax: {
            inlineMath: [ ["$","$"], ["\\(","\\)"] ],
            skipTags: ['script', 'noscript', 'style', 'textarea', 'pre', 'code'],
            processEscapes: true
        }
    });
    MathJax.Hub.Queue(function() {
        var all = MathJax.Hub.getAllJax();
        for (var i = 0; i < all.length; ++i)
            all[i].SourceElement().parentNode.className += ' has-jax';
    });
</script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-MML-AM_CHTML"></script>
</body>
</html>